package com.hancheng.commoncloud.framework.util;

import cn.hutool.core.util.StrUtil;
import com.hancheng.commoncloud.framework.contant.Constants;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.*;
import java.net.URLDecoder;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


/**
 * 字串工具类
 * @author 金笛
 * @date 2022/1/23 16:05
 */
public class StringUtil {

    public static final char UNDERLINE = '_';
    public static final String ONE_STR = "1";
    public static final String CSV_SEPARATOR = ",";
    public static final String CSV_SEPARATOR_WITH_SPACE = ", ";
    private static final Pattern REGEXP_isInteger = Pattern.compile("^\\s*(\\+|-)?\\d+\\s*$", Pattern.CASE_INSENSITIVE);
    private static final Logger LOG = LoggerFactory.getLogger(StringUtil.class);

    private StringUtil() {
    }


    /**
     * 将一个Double转为int的String，将省略小数点后面的值
     *
     * @param d
     * @return
     */
    public static String doubleToIntString(Double d) {
        int value = ((Double) d).intValue();
        return String.valueOf(value);
    }

    /**
     * 检查浮点数
     *
     * @param num
     * @param type "0+":非负浮点数 "+":正浮点数 "-0":非正浮点数 "-":负浮点数 "":浮点数
     * @return
     */
    public static boolean checkFloat(String num, String type) {
        String eL = "";
        if (type.equals("0+")) {
            // 非负浮点数
            eL = "^\\d+(\\.\\d+)?$";
        } else if (type.equals("+")) {
            // 正浮点数
            eL = "^((\\d+\\.\\d*[1-9]\\d*)|(\\d*[1-9]\\d*\\.\\d+)|(\\d*[1-9]\\d*))$";
        } else if (type.equals("-0")) {
            // 非正浮点数
            eL = "^((-\\d+(\\.\\d+)?)|(0+(\\.0+)?))$";
        } else if (type.equals("-")) {
            // 负浮点数
            eL = "^(-((\\d+\\.\\d*[1-9]\\d*)|(\\d*[1-9]\\d*\\.\\d+)|(\\d*[1-9]\\d*)))$";
        } else {
            // 浮点数
            eL = "^(-?\\d+)(\\.\\d+)?$";
        }
        Pattern p = Pattern.compile(eL);
        Matcher m = p.matcher(num);
        boolean b = m.matches();
        return b;
    }

    /**
     * 检测某字串是否存在某数组中
     *
     * @param value
     * @param array
     * @return 存在返回真，不存在返回假
     */
    public static boolean isInArray(String value, String[] array) {
        if (array == null) {
            return false;
        }
        for (String v : array) {
            if (v.equals(value)) {
                return true;
            }
        }
        return false;

    }

    public static boolean isInArray(int value, String[] array) {
        if (array == null) {
            return false;
        }
        for (String v : array) {
            if (Integer.valueOf(v).intValue() == value) {
                return true;
            }
        }
        return false;
    }

    /**
     * 将数组成str连接成字符串
     *
     * @param str
     * @param array
     * @return
     */
    public static String implode(String str, Object[] array) {
        if (str == null || array == null) {
            return "";
        }
        String result = "";
        for (int i = 0; i < array.length; i++) {
            if (i == array.length - 1) {
                result += array[i].toString();
            } else {
                result += array[i].toString() + str;
            }
        }
        return result;
    }

    public static String implodeValue(String str, Object[] array) {
        if (str == null || array == null) {
            return "";
        }
        String result = "";
        for (int i = 0; i < array.length; i++) {
            if (i == array.length - 1) {
                result += "?";
            } else {
                result += "?" + str;
            }
        }
        return result;
    }

    /**
     * MD5加密方法
     *
     * @param str String
     * @return String
     */
    public static String md5(String str) {
        return md5(str, true);
    }

    public static String md5(String str, boolean zero) {
        MessageDigest messageDigest = null;
        try {
            messageDigest = MessageDigest.getInstance("MD5");
        } catch (NoSuchAlgorithmException ex) {
            ex.printStackTrace();
            return null;
        }
        byte[] resultByte = messageDigest.digest(str.getBytes());
        StringBuffer result = new StringBuffer();
        for (int i = 0; i < resultByte.length; ++i) {
            int v = 0xFF & resultByte[i];
            if (v < 16 && zero)
                result.append("0");
            result.append(Integer.toHexString(v));
        }
        return result.toString();
    }


    public static void main(String[] args) {
        System.out.println(md5("123456"));
        System.out.println(md5("111111"));
        System.out.println(getCSV(splitKeywords("蚕丝被")));
        System.out.println(splitKeywords("被子"));
    }


    /**
     * 验证Email地址是否有效
     *
     * @param sEmail
     * @return
     */
    public static boolean validEmail(String sEmail) {
        String pattern = "^([a-z0-9A-Z]+[-|\\.|_]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
        return sEmail.matches(pattern);
    }

    /**
     * 验证字符最大长度
     *
     * @param str
     * @return
     */
    public static boolean validMaxLen(String str, int length) {
        if (str == null && str.equals("")) {
            return false;
        }
        if (str.length() > length) {
            return false;
        } else {
            return true;
        }
    }

    /**
     * 验证字符最小长度
     *
     * @param str
     * @return
     */
    public static boolean validMinLen(String str, int length) {
        if (str == null && str.equals("")) {
            return false;
        }
        if (str.length() < length) {
            return false;
        } else {
            return true;
        }
    }

    /**
     * 验证一个字符串是否为空
     *
     * @param str
     * @return 如果为空返回真，如果不为空返回假
     */

    public static boolean isEmpty(String str) {
        if (str == null || "".equals(str)) {
            return true;
        }
        String pattern = "\\S";
        Pattern p = Pattern.compile(pattern, 2 | Pattern.DOTALL);
        Matcher m = p.matcher(str);
        return !m.find();
    }

    /**
     * 验证两个字符串是否相等且不能为空
     *
     * @param str1
     * @param str2
     * @return
     */
    public static boolean equals(String str1, String str2) {
        if (str1 == null || str1.equals("") || str2 == null || str2.equals("")) {
            return false;
        }
        return str1.equals(str2);
    }

    /**
     * 将字串转为数字
     *
     * @param str
     * @param checked 如果为treu格式不正确抛出异常
     * @return
     */
    public static int toInt(String str, boolean checked) {
        int value = 0;
        if (str == null || str.equals("")) {
            return 0;
        }
        try {
            value = Integer.parseInt(str);
        } catch (Exception ex) {
            if (checked) {
                throw new RuntimeException("整型数字格式不正确");
            } else {
                return 0;
            }
        }
        return value;
    }

    /**
     * 将一个字串转为int，如果无空，则返回默认值
     *
     * @param str          要转换的数字字串
     * @param defaultValue 默认值
     * @return
     */
    public static Integer toInt(String str, Integer defaultValue) {
        Integer value = defaultValue;
        if (str == null || str.equals("")) {
            return defaultValue;
        }
        try {
            value = Integer.parseInt(str);
        } catch (Exception ex) {
            throw new RuntimeException("整型数字格式不正确:" + str);
        }
        return value;
    }

    /**
     * 将字符型转为Int型
     *
     * @param str
     * @return
     */
    @Deprecated
    public static int toInt(String str) {
        int value = 0;
        if (str == null || str.equals("")) {
            return 0;
        }
        try {
            value = Integer.parseInt(str);
        } catch (Exception ex) {
            value = 0;
            ex.printStackTrace();
        }
        return value;
    }

    @Deprecated
    public static Double toDouble(String str) {
        Double value = 0d;
        if (str == null || str.equals("")) {
            return 0d;
        }
        try {
            value = Double.valueOf(str);
        } catch (Exception ex) {
            value = 0d;
            // ex.printStackTrace();
        }
        return value;
    }

    /**
     * 将一个字串转为double
     *
     * @param str
     * @param checked 如果为treu格式不正确抛出异常
     * @return
     */
    public static Double toDouble(String str, boolean checked) {
        Double value = 0d;
        if (str == null || str.equals("")) {
            return 0d;
        }
        try {
            value = Double.valueOf(str);
        } catch (Exception ex) {
            if (checked) {
                throw new RuntimeException("数字格式不正确");
            } else {
                return 0D;
            }
        }
        return value;
    }

    public static Double toDouble(String str, Double defaultValue) {
        Double value = defaultValue;
        if (str == null || str.equals("")) {
            return 0d;
        }
        try {
            value = Double.valueOf(str);
        } catch (Exception ex) {
            ex.printStackTrace();
            value = defaultValue;
        }
        return value;
    }


    /**
     * 把数组转换成String
     *
     * @param array
     * @return
     */
    public static String arrayToString(Object[] array, String split) {
        if (array == null) {
            return "";
        }
        String str = "";
        for (int i = 0; i < array.length; i++) {
            if (i != array.length - 1) {
                str += array[i].toString() + split;
            } else {
                str += array[i].toString();
            }
        }
        return str;
    }

    /**
     * 将一个list转为以split分隔的string
     *
     * @param list
     * @param split
     * @return
     */
    public static String listToString(List list, String split) {
        if (list == null || list.isEmpty()) {
            return "";
        }
        StringBuffer sb = new StringBuffer();
        for (Object obj : list) {
            if (sb.length() != 0) {
                sb.append(split);
            }
            sb.append(obj.toString());
        }
        return sb.toString();
    }

    /**
     * 得到WEB-INF的绝对路径
     *
     * @return
     */
    public static String getWebInfPath() {
        String filePath = Thread.currentThread().getContextClassLoader()
                .getResource("").toString();
        if (filePath.toLowerCase().indexOf("file:") > -1) {
            filePath = filePath.substring(6, filePath.length());
        }
        if (filePath.toLowerCase().indexOf("classes") > -1) {
            filePath = filePath.replaceAll("/classes", "");
        }
        if (System.getProperty("os.name").toLowerCase().indexOf("window") < 0) {
            filePath = "/" + filePath;
        }
        if (!filePath.endsWith("/")) {
            filePath += "/";
        }
        return filePath;
    }

    /**
     * 得到根目录绝对路径(不包含WEB-INF)
     *
     * @return
     */
    public static String getRootPath() {
        String filePath = StringUtil.class.getResource("").toString();

        int index = filePath.indexOf("WEB-INF");
        if (index == -1) {
            index = filePath.indexOf("build");
        }

        if (index == -1) {
            index = filePath.indexOf("bin");
        }

        filePath = filePath.substring(0, index);
        if (filePath.startsWith("jar")) {
            // 当class文件在jar文件中时，返回”jar:file:/F:/ …”样的路径
            filePath = filePath.substring(10);
        } else if (filePath.startsWith("file")) {
            // 当class文件在jar文件中时，返回”file:/F:/ …”样的路径
            filePath = filePath.substring(6);
        }


        if (System.getProperty("os.name").toLowerCase().indexOf("window") < 0) {
            filePath = "/" + filePath;
        }

        if (filePath.endsWith("/")) {
            filePath = filePath.substring(0, filePath.length() - 1);
        }

        return filePath;
    }

    /**
     * 格式化页码
     *
     * @param page
     * @return
     */
    public static int formatPage(String page) {
        int iPage = 1;
        if (page == null || page.equals("")) {
            return iPage;
        }
        try {
            iPage = Integer.parseInt(page);
        } catch (Exception ex) {
            iPage = 1;
        }
        return iPage;
    }

    /**
     * 将计量单位字节转换为相应单位
     *
     * @param fileSize
     * @return
     */
    public static String getFileSize(String fileSize) {
        String temp = "";
        DecimalFormat df = new DecimalFormat("0.00");
        double dbFileSize = Double.parseDouble(fileSize);
        if (dbFileSize >= 1024) {
            if (dbFileSize >= 1048576) {
                if (dbFileSize >= 1073741824) {
                    temp = df.format(dbFileSize / 1024 / 1024 / 1024) + " GB";
                } else {
                    temp = df.format(dbFileSize / 1024 / 1024) + " MB";
                }
            } else {
                temp = df.format(dbFileSize / 1024) + " KB";
            }
        } else {
            temp = df.format(dbFileSize / 1024) + " KB";
        }
        return temp;
    }

    /**
     * 得到一个32位随机字符
     *
     * @return
     */
    public static String getEntry() {
        Random random = new Random(100);
        Date now = new Date();
        SimpleDateFormat formatter = new SimpleDateFormat(new String(
                "yyyyMMddHHmmssS"));
        return md5(formatter.format(now) + random.nextDouble());
    }

    /**
     * 将中文汉字转成UTF8编码
     *
     * @param str
     * @return
     */
    public static String toUTF8(String str) {
        if (str == null || str.equals("")) {
            return "";
        }
        try {
            return new String(str.getBytes("ISO8859-1"), "UTF-8");
        } catch (Exception ex) {
            ex.printStackTrace();
            return "";
        }
    }

    public static String to(String str, String charset) {

        if (str == null || str.equals("")) {
            return "";
        }
        try {
            return new String(str.getBytes("ISO8859-1"), charset);
        } catch (Exception ex) {
            LOG.error("", ex);
            return str;
        }
    }

    public static String getRandStr(int n) {
        Random random = new Random();
        String sRand = "";
        for (int i = 0; i < n; i++) {
            String rand = String.valueOf(random.nextInt(10));
            sRand += rand;
        }
        return sRand;
    }

    /**
     * 得到一个数字的大写(一到十之内)
     *
     * @param num
     * @return
     */
    public static String getChineseNum(int num) {
        String[] chineseNum = new String[]{"一", "二", "三", "四", "五", "六", "七",
                "八", "九", "十"};
        return chineseNum[num];
    }

    public static String replaceEnter(String str) {
        if (str == null) {
            return null;
        }
        return str.replaceAll("\r", "").replaceAll("\n", "");
    }

    public static String replaceAll(String source, String target, String content) {
        StringBuffer buffer = new StringBuffer(source);
        int start = buffer.indexOf(target);
        if (start > 0) {
            source = buffer.replace(start, start + target.length(), content)
                    .toString();
        }
        return source;
    }
    private static   Pattern pattern = Pattern.compile("<[^<|^>]*>");
    /**
     * 去除HTML 元素
     *
     * @param element
     * @return
     */
    public static String getTxtWithoutHTMLElement(String element) {
        if (null == element || "".equals(element.trim())) {
            return element;
        }


        Matcher matcher = pattern.matcher(element);
        StringBuffer txt = new StringBuffer();
        while (matcher.find()) {
            String group = matcher.group();
            if (group.matches("<[\\s]*>")) {
                matcher.appendReplacement(txt, group);
            } else {
                matcher.appendReplacement(txt, "");
            }
        }
        matcher.appendTail(txt);
        String temp = txt.toString().replaceAll("\n", "");
        temp = temp.replaceAll(" ", "");
        return temp;
    }

    /**
     * clear trim to String
     *
     * @return
     */
    public static String toTrim(String strtrim) {
        if (null != strtrim && !strtrim.equals("")) {
            return strtrim.trim();
        }
        return "";
    }

    /**
     * 转义字串的$
     *
     * @param str
     * @return
     */
    public static String filterDollarStr(String str) {
        String sReturn = "";
        if (!toTrim(str).equals("")) {
            if (str.indexOf('$', 0) > -1) {
                while (str.length() > 0) {
                    if (str.indexOf('$', 0) > -1) {
                        sReturn += str.subSequence(0, str.indexOf('$', 0));
                        sReturn += "\\$";
                        str = str.substring(str.indexOf('$', 0) + 1,
                                str.length());
                    } else {
                        sReturn += str;
                        str = "";
                    }
                }

            } else {
                sReturn = str;
            }
        }
        return sReturn;
    }

    public static String compressHtml(String html) {
        if (html == null)
            return null;

        html = html.replaceAll("[\\t\\n\\f\\r]", "");
        return html;
    }

    public static String toCurrency(Double d) {
        if (d != null) {
            DecimalFormat df = new DecimalFormat("￥#,###.00");
            return df.format(d);
        }
        return "";
    }

    public static String toString(Integer i) {
        if (i != null) {
            return String.valueOf(i);
        }
        return "";
    }

    public static String toString(Double d) {
        if (null != d) {
            return String.valueOf(d);
        }
        return "";
    }

    public static String getRandom() {
        int[] array = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
        Random rand = new Random();
        for (int i = 10; i > 1; i--) {
            int index = rand.nextInt(i);
            int tmp = array[index];
            array[index] = array[i - 1];
            array[i - 1] = tmp;
        }
        int result = 0;
        for (int i = 0; i < 6; i++) {
            result = result * 10 + array[i];
        }

        return "" + result;
    }

    /**
     * 处理树型码 获取本级别最大的code 如:301000 返回301999
     *
     * @param code
     * @return
     */
    public static int getMaxLevelCode(int code) {
        String codeStr = "" + code;
        StringBuffer str = new StringBuffer();
        boolean flag = true;
        for (int i = codeStr.length() - 1; i >= 0; i--) {
            char c = codeStr.charAt(i);
            if (c == '0' && flag) {
                str.insert(0, '9');
            } else {
                str.insert(0, c);
                flag = false;
            }
        }
        return Integer.valueOf(str.toString());
    }

    /**
     * 去掉sql的注释
     */
    public static String delSqlComment(String content) {
        String pattern = "/\\*(.|[\r\n])*?\\*/";
        Pattern p = Pattern.compile(pattern, 2 | Pattern.DOTALL);
        Matcher m = p.matcher(content);
        if (m.find()) {
            content = m.replaceAll("");
        }
        return content;
    }

    public static String inputStream2String(InputStream is) {
        BufferedReader in = new BufferedReader(new InputStreamReader(is));
        StringBuffer buffer = new StringBuffer();
        String line = "";
        try {
            while ((line = in.readLine()) != null) {
                buffer.append(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return buffer.toString();
    }

    public static String decode(String keyword) {
        try {
            keyword = URLDecoder.decode(keyword, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        return keyword;
    }

    /**
     * 进行解析
     *
     * @param regex
     * @param rpstr
     * @param source
     * @return
     */
    public static String doFilter(String regex, String rpstr, String source) {
        Pattern p = Pattern.compile(regex, 2 | Pattern.DOTALL);
        Matcher m = p.matcher(source);
        return m.replaceAll(rpstr);
    }

    /**
     * 脚本过滤
     *
     * @param source
     * @return
     */
    public static String formatScript(String source) {
        source = source.replaceAll("javascript", "&#106avascript");
        source = source.replaceAll("jscript:", "&#106script:");
        source = source.replaceAll("js:", "&#106s:");
        source = source.replaceAll("value", "&#118alue");
        source = source.replaceAll("about:", "about&#58");
        source = source.replaceAll("file:", "file&#58");
        source = source.replaceAll("document.cookie", "documents&#46cookie");
        source = source.replaceAll("vbscript:", "&#118bscript:");
        source = source.replaceAll("vbs:", "&#118bs:");
        source = doFilter("(on(mouse|exit|error|click|key))", "&#111n$2",
                source);
        return source;
    }

    /**
     * 格式化HTML代码
     *
     * @param htmlContent
     * @return
     */
    public static String htmlDecode(String htmlContent) {
        htmlContent = formatScript(htmlContent);
        htmlContent = htmlContent.replaceAll(" ", "&nbsp;")
                .replaceAll("<", "&lt;").replaceAll(">", "&gt;")
                .replaceAll("\n\r", "<br>").replaceAll("\r\n", "<br>")
                .replaceAll("\r", "<br>");
        return htmlContent;
    }

    /**
     * 动态添加表前缀，对没有前缀的表增加前缀
     *
     * @param table
     * @param prefix
     * @return
     */
    public static String addPrefix(String table, String prefix) {
        String result = "";
        if (table.length() > prefix.length()) {
            if (table.substring(0, prefix.length()).toLowerCase()
                    .equals(prefix.toLowerCase())) {
                result = table;
            } else {
                result = prefix + table;
            }
        } else {
            result = prefix + table;
        }

        return result;
    }

    public static String addSuffix(String table, String suffix) {
        String result = "";
        if (table.length() > suffix.length()) {
            int start = table.length() - suffix.length();
            int end = start + suffix.length();
            if (table.substring(start, end).toLowerCase()
                    .equals(suffix.toLowerCase())) {
                result = table;
            } else {
                result = table + suffix;
            }
        } else {
            result = table + suffix;
        }

        return result;
    }


    /**
     * 得到异常的字串
     *
     * @param aThrowable
     * @return
     */
    public static String getStackTrace(Throwable aThrowable) {
        final Writer result = new StringWriter();
        final PrintWriter printWriter = new PrintWriter(result);
        aThrowable.printStackTrace(printWriter);
        return result.toString();

    }

    /**
     * get CSV string from the array. use comma as separator. blank items will be skipped.
     *
     * @param stringArray
     * @return StringBuffer
     */
    public static StringBuffer getCSV(String[] stringArray) {
        return getCSV(Arrays.asList(stringArray), CSV_SEPARATOR, true);
    }

    /**
     * get CSV string from the collections. use comma as separator. blank items will be skipped.
     *
     * @param values Collection
     * @return StringBuffer
     */
    public static StringBuffer getCSV(Collection values) {
        return getCSV(values, CSV_SEPARATOR, true);
    }

    /**
     * get CSV string from the collections. use separator as separator. blank items will be skipped.
     *
     * @param values
     * @param separator
     * @return
     */
    public static StringBuffer getCSV(Collection values, String separator) {
        return getCSV(values, separator, true);
    }

    /**
     * convert the collection into CSV.
     *
     * @param values
     * @param separators
     * @param ignoreBlank if true blank entries will be skipped
     * @return StringBuffer
     */
    private static StringBuffer getCSV(Collection values, String separators, boolean ignoreBlank) {
        StringBuffer b = new StringBuffer();
        if (values == null || values.size() == 0) {
            return b;
        }

        for (Iterator it = values.iterator(); it.hasNext(); ) {
            String v = it.next().toString();
            if (ignoreBlank && StringUtil.isEmpty(v)) {
                continue;
            }

            if (b.length() > 0) {
                b.append(separators);
            }
            b.append(v);
        }

        return b;
    }

    /**
     * Splits a string into an array of string tokens.
     *
     * @param str   a string
     * @param sep   a string containing the string separators
     * @param count the desired number of string tokens
     * @return an array of string tokens
     */
    public static String[] split(String str, String sep, int count) {
        if (str == null || str.length() == 0 || count == 0 || count < -1) {
            return null;
        }

        StringTokenizer tokenizer = new StringTokenizer(str, sep,
                count == -1 ? false : true);

        if (count == -1) {
            count = tokenizer.countTokens();
        }

        String[] result = new String[count];
        int i = 0;
        while (tokenizer.hasMoreTokens()) {
            String t = tokenizer.nextToken();
            if (i < count) {
                if ((t.length() == 1) && (sep.indexOf(t) != -1)) {
                    continue;
                }
                result[i++] = t;
            } else {
                result[count - 1] += t;
            }
        }
        return result;
    }

    public static String[] split(String str) {
        return split(str, CSV_SEPARATOR, -1);
    }

    /**
     * Splits a string into an array of string tokens.
     *
     * @param str a string
     * @param sep a string containing the string separators
     * @return an array of string tokens
     */
    public static String[] split(String str, String sep) {
        return split(str, sep, -1);
    }

    public static boolean getBoolean(Object value) {
        if (value == null) {
            return false;
        }

        return stringToBoolean(value.toString());
    }

    /**
     * convert a string to a boolean value returns true or false
     */
    public static boolean stringToBoolean(String strValue) {

        /*
         * if ( (strValue == null ) || strValue.equals("") ||
         * strValue.trim().equalsIgnoreCase(DataUtil.ZERO_STR) ||
         * strValue.trim().equalsIgnoreCase("false") ) { return false; } else {
         * return true; }
         */
        return ((strValue != null) && (strValue.equalsIgnoreCase("true")
                || strValue.equalsIgnoreCase("on")
                || strValue.equalsIgnoreCase("yes")
                || strValue.toLowerCase().startsWith("y") || strValue
                .toLowerCase().startsWith(ONE_STR)));
    }

    /**
     * get the string value of the value object
     *
     * @param value
     * @return String the string value
     */
    public static String toString(Object value) {

        if (value instanceof String[]) {
            StringBuffer sb = new StringBuffer();
            for (String s : (String[]) value) {
                if (sb.length() > 0) {
                    sb.append(StringUtil.CSV_SEPARATOR);
                }
                sb.append(s);
            }

            return sb.toString();
        }

        if (value instanceof Integer[]) {
            StringBuffer sb = new StringBuffer();
            for (Integer s : (Integer[]) value) {
                if (sb.length() > 0) {
                    sb.append(StringUtil.CSV_SEPARATOR);
                }
                sb.append(s);
            }

            return sb.toString();
        }

        if (value instanceof Object[]) {
            StringBuffer sb = new StringBuffer();
            for (Object s : (Object[]) value) {
                if (sb.length() > 0) {
                    sb.append(StringUtil.CSV_SEPARATOR);
                }
                sb.append(s.toString());
            }

            return sb.toString();
        }

        return (value == null) ? "" : value.toString();
    }

    public static int stringPxToInt(Object obj) {
        if (obj == null) {
            return 0;
        }

        String pxStr = obj.toString();
        if (isEmpty(pxStr) || "100%".equals(pxStr)) {
            return 0;
        }

        return toInt(pxStr.replace("px", ""), 0);
    }

    public static int toInt(Object value) {
        return (int) toLong(value);
    }

    public static double toDouble(Object value) {
        Double d = toDoubleObj(value);
        return d == null ? 0 : d.doubleValue();
    }

    public static long toLong(Object value) {
        if (value == null || value.toString().length() == 0)
            return 0;
        if (value instanceof Integer) {
            return ((Integer) value).longValue();
        } else if (value instanceof Long) {
            return ((Long) value).longValue();
        } else if (value instanceof Short) {
            return ((Short) value).longValue();
        } else if (value instanceof Float) {
            return ((Float) value).longValue();
        } else if (value instanceof Double) {
            return ((Double) value).longValue();
        }

        if (isInteger(value.toString())) {
            return Long.parseLong(value.toString().trim());
        }

        return 0;
    }

    public static Double toDoubleObj(Object value) {

        if (value == null) {
            return null;
        }

        if (value instanceof Double) {
            return (Double) value;
        } else if (value.toString().equals("")) {
            return new Double(0.0);
        } else {
            return new Double(value.toString());
        }

    }

    /**
     * check if the string is a long or integer number
     *
     * @param v String
     * @return boolean
     */
    public static boolean isInteger(String v) {

        if (StringUtil.isEmpty(v)) {
            return false;
        }

        try {
            Matcher matcher = REGEXP_isInteger.matcher(v);
            return matcher.find();
        } catch (Exception ex) {
            ex.printStackTrace();
        }

        return false;
    }

    public static String[] splitKeywords(String keywords) {
        if (isEmpty(keywords)) {
            return new String[]{};
        }

        String[] strs = keywords.split("");

        String str = "";
        String[] result = new String[strs.length - 1];
        for (int i = 1; i < strs.length; i++) {
            if (isEmpty(strs[i])) {
                continue;
            }
            str += strs[i];
            result[strs.length - (i + 1)] = str;
        }

        return result;
    }

    /**
     * 转换驼峰为下划线字符串
     *
     * @param param
     * @return
     */
    public static String camelToUnderline(String param) {
        if (param == null || "".equals(param.trim())) {
            return "";
        }
        int len = param.length();
        StringBuilder sb = new StringBuilder(len);
        for (int i = 0; i < len; i++) {
            char c = param.charAt(i);
            if (Character.isUpperCase(c)) {
                sb.append(UNDERLINE);
                sb.append(Character.toLowerCase(c));
            } else {
                sb.append(c);
            }
        }
        return sb.toString();
    }

    /**
     * 将以逗号分隔的字符串排序
     *
     * @param str
     * @return
     */
    public static String stringSort(String str){
        if (StrUtil.isNotBlank(str)){
            // 将逗号隔开的字符串分割成数组
            String[] codes = str.split(",");

            // 对数组进行排序
            Arrays.sort(codes);

            // 将排序后的数组拼接成字符串
            return String.join(",", codes);
        }
        return null;
    }

    /**
     * 获取某个字符之后的字符串
     *
     * @param symbol
     * @param allStr
     * @return
     */
    public static String getAfter(String symbol, String allStr) {
        return StrUtil.isNotBlank(allStr) ? allStr.substring(allStr.indexOf(symbol) + Constants.ONE) : null;
    }

    /**
     * 获取某个字符之前的字符串
     *
     * @param symbol
     * @param allStr
     * @return
     */
    public static String getBefore(String symbol, String allStr) {
        return StrUtil.isNotBlank(allStr) ? allStr.substring(Constants.ZERO, allStr.indexOf(symbol)) : null;
    }
}
